let java=`
JAVA笔记

#$
动态改变控件宽高位置
LinearLayout.LayoutParams parms=(LinearLayout.LayoutParams)imglab_target.getLayoutParams();
				parms.leftMargin = (int) dx;
				parms.topMargin = (int) dy;
                parms.width=(int) event.getX()-dx;
				parms.height=(int) event.getY()-dy;
				imglab_target.setLayoutParams(parms);        
				imglab_target.invalidate();



#$
#获取数组中最大最小值
int ages[] = {18 ,23 ,21 ,19 ,25 ,29 ,17};
int maxNum = Arrays.stream(ages).max().getAsInt();
				

#$
int[] numbers={18 ,23 ,21 ,19 ,25 ,29 ,17};
				int i,j;
		        /*顺序冒泡排序*/
				for(i=0;i<numbers.length-1;i++)
				{
					for(j=0;j<numbers.length-1-i;j++)
					{
						if(numbers[j]>numbers[j+1])
						{
							int temp=numbers[j];
							numbers[j]=numbers[j+1];
							numbers[j+1]=temp;
						}
					}
				}

#$
    // 声明HashMap对象
 8         Map<String,Integer> map= new HashMap<>();
 9 
10         //添加数据
11         map.put("ZhangYi",98);
12         map.put("WangEr",99);
13         map.put("ZhangShan",89);
14         map.put("Lisi",92);
15 
16         //根据键值对键值获取数据‘’
17         int value=map.get("Lisi");
18         System.out.println("kay:Lisi And value:"+value);
19 
20         //获取Map中键值对的个数
21         int size=map.size();
22         System.out.println("map 中的键值对个数为："+size);
23 
24         //判断Map集合中是否包含键为key的键值对
25         boolean b1=map.containsKey("LiSI");
26         boolean b2=map.containsKey("Lisi");
27         System.out.println("是否包含键值为LiSI的键值对数据："+b1);
28         System.out.println("是否包含键值为Lisi的键值对数据："+b2);
29 
30         //判断Map集合中是否包含值为value的键值对
31         boolean b3=map.containsValue(99);
32         boolean b4=map.containsValue(100);
33         System.out.println("是否包含值为99的键值对数据："+b3);
34         System.out.println("是否包含值为100的键值对数据："+b4);
35 
36         //判断Map集合中是否没有任何键值对
37 
38         boolean b5=map.isEmpty();
39         System.out.println("map中键值对数据是否为空："+b5);
40 
41         //根据键值删除Map中键值对
42         int value2=map.remove("Lisi");
43         System.out.println("删除了键为Lisi的键值对数据，其值为："+value2);
44 
45         boolean b6=map.containsKey("Lisi");
46         System.out.println("是否包含键值为Lisi的键值对数据："+b6);
47 
48         //清空Map集合中所有的键值对
49         map.clear();
50         boolean b7=map.isEmpty();
51         System.out.println("map中键值对数据是否为空："+b7);
52 
53     }
54 }
复制代码
 

输出结果为：

复制代码
kay:Lisi And value:92
map 中的键值对个数为：4
是否包含键值为LiSI的键值对数据：false
是否包含键值为Lisi的键值对数据：true
是否包含值为99的键值对数据：true
是否包含值为100的键值对数据：false
map中键值对数据是否为空：false
删除了键为Lisi的键值对数据，其值为：92
是否包含键值为Lisi的键值对数据：false
map中键值对数据是否为空：true
复制代码
 

 

键值对数据遍历

（1）将Map中所有的键装到Set集合中返回

//public Set<K> keySet();
Set<K> set=map. keySet() 
（2）返回集合中所有的value的值的集合

// public Collection<V> values();
Collection<V> c=map.values()
（3）将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回

// public Set<Map.Entry<K,V>> entrtSet();
Set<Map.Entry<K,V>> entrys=map.entrySet()
示例：

复制代码
 1 import java.util.Collection;
 2 import java.util.HashMap;
 3 import java.util.Map;
 4 import java.util.Set;
 5 
 6 public class Demo02 {
 7     public static void main(String[] args) {
 8         // 声明HashMap对象
 9         Map<String,Integer> map= new HashMap<>();
10 
11         //添加数据
12         map.put("ZhangYi",98);
13         map.put("WangEr",99);
14         map.put("ZhangShan",89);
15         map.put("Lisi",92);
16 
17         //（1）将Map中所有的键装到Set集合中返回
18         Set<String> keys=map.keySet();
19         for(String key:keys){
20             int value=map.get(key);
21             System.out.println("key:"+key+"  and  value:"+value);
22         }
23 
24         //（2）返回集合中所有的value的值的集合
25         Collection<Integer> values=map.values();
26         for(int value:values){
27             System.out.print(value+"   ");
28         }
29         System.out.println();
30 
31         //（3）将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回
32         Set<Map.Entry<String,Integer>> entries=map.entrySet();
33         for(Map.Entry<String,Integer> entry :entries){
34             String key=entry.getKey();
35             int value=entry.getValue();
36             System.out.println("key:"+key+"  and  value:"+value);
37         }
38     }

#$
//保存bitmap
private void saveBitmap(Bitmap bitmap, String filePath) {
        try {
            FileOutputStream outputStream = new FileOutputStream(filePath);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
#$
//获取当前毫秒数
long t1 = System.currentTimeMillis();
         
#$
//以流的方式读取sd卡图片
	public static void ShowImg(String uri, ImageView iv) throws IOException {	
		FileInputStream fs = new FileInputStream(uri);
		BufferedInputStream bs = new BufferedInputStream(fs);
		Bitmap btp = BitmapFactory.decodeStream(bs);
		iv.setImageBitmap(btp);
		bs.close();
		fs.close();
		btp = null;		
	}
#$
verifyStoragePermissions(this);//使用

/*
	*动态获取SD卡读取权限
	*/
	private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private static String[] PERMISSIONS_STORAGE = {
		"android.permission.READ_EXTERNAL_STORAGE",
		"android.permission.WRITE_EXTERNAL_STORAGE" };	
public static void verifyStoragePermissions(Activity activity) {

        try {
			//检测是否有写的权限
            int permission = ActivityCompat.checkSelfPermission(activity,
																"android.permission.WRITE_EXTERNAL_STORAGE");
            if (permission != PackageManager.PERMISSION_GRANTED) {
				// 没有写的权限，去申请写的权限，会弹出对话框
                ActivityCompat.requestPermissions(activity, PERMISSIONS_STORAGE,REQUEST_EXTERNAL_STORAGE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

#$
//线程
new Thread(new Runnable(){
					@Override
					public void run()
					{
					
					}});


#$
	/** 
	 * 获取SDCard的目录路径功能 
	 * @return 
	 */ 
	private String getSDCardPath(){ 
		File sdcardDir = null; 
		//判断SDCard是否存在 
		boolean sdcardExist = Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED); 
		if(sdcardExist){ 
			sdcardDir = Environment.getExternalStorageDirectory(); 
		} 
		return sdcardDir.toString(); 
	}

#$
//JAVA UDP
	new Thread(new Runnable(){
					@Override
					public void run()
					{
						long time=new Date().getTime();
						ByteArrayOutputStream byteArray_ops=new ByteArrayOutputStream();//相当于有根管道对接到分配的内存,可通过此管道写入数据
						DataOutputStream data_ops= new DataOutputStream(byteArray_ops) ;//只有 dataOutputStream类型才能直接往外写一个long类型的数,套到ByteArrayOutputStream管道外面				try
						{
							data_ops.writeLong(time);//写入long数据到内存
						}
						catch (IOException e)
						{}
						byte[] long_byte=byteArray_ops.toByteArray();//字节数组转为字节,可直接发送到服务器

						String str = String.valueOf(time);//long转string
						
						byte[] str_byte=(str).getBytes();
						
						
						
						byte[] buf=(new String("cscs")).getBytes();//字符串转为字节

						DatagramPacket dataPack=new DatagramPacket(str_byte,str_byte.length,new InetSocketAddress("127.0.0.1",9999));//接收者的ip和端口
						DatagramSocket dataSocket = null;
						try
						{
							dataSocket=new DatagramSocket(45678);//发送者的端口
						}
						catch (SocketException e)
						{}
						try
						{
							dataSocket.send(dataPack);

						}
						catch (IOException e)
						{}

						dataSocket.close();					
						
			}
		}).start();
	
#$
//获取CPU核数
int num=Runtime.getRuntime().availableProcessors();
#$
接口
接口是一种公共的规范标准。


#$
	
	/*
	
	三个参数为泛型
	参数一:执行子线程所需要的参数类型 (不需要传入void)
	 参数二:进度指示所需类型 Integer
	参数三:运行返回结果类型
	 使用:new MyTask().execute();
	*/
	 class MyTask extends AsyncTask<Void,Integer,Void>{

		/*
		doInBackground运行在后台，相当于线程中的run方法
		
		*/
		@Override
		protected Void doInBackground(Void[] p1)
		{
			for(int i=1;i<100;i++){
				try
				{
					Thread.sleep(1);
				}
				catch (InterruptedException e)
				{}
				publishProgress(i);//onProgressUpdate方法传数据
			}
			return null;
		}

		
		
		
		/*
		进度指示方法
		此方法运行在主线程,此方法可以直接更改控件属性
		*/
		@Override
		protected void onProgressUpdate(Integer[] values)
		{
			int num=values[0];
			Toast.makeText(SocketActivity.this,String.valueOf(num),Toast.LENGTH_LONG).show();
			
			textV.setText(String.valueOf(num));
			super.onProgressUpdate(values);
		}

		
		/*
		运行在主线程中,子线程运行结束自动调用的方法(和传入参数三类型对应)
		*/
		@Override
		protected void onPostExecute(Void result)
		{
			Toast.makeText(SocketActivity.this,"子线程运行结束!",Toast.LENGTH_LONG).show();
			super.onPostExecute(result);
		}
		
		
	}
#$
this和super
this是当前对象的引用
this()放在构造方法第一行表示父类构造方法

super表示取父类的东西
super()一样



#$
//间接设置私有属性
private int arg;

setArg(int arg){
    arg=arg;
}

getArg(){
    return arg;
}


//间接获取私有属性


#$
@Override(复写。意思是下面的类定义在父类中)
public 类名 ...

#$
/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;

流程：
首先判断条件是否成立：
	如果成立为true，那么将表达式A的值赋值给左侧的变量；
	如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。

注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。
*/
public class Demo10Operator {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		// 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
		// 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
		int max = a > b ? a : b; // 最大值的变量
		System.out.println("最大值：" + max); // 20
		
		// int result = 3 > 4 ? 2.5 : 10; // 错误写法！
		
		System.out.println(a > b ? a : b); // 正确写法！
		
		// a > b ? a : b; // 错误写法！
	}
}



#$
/*
四则运算当中的加号“+”有常见的三种用法：

1. 对于数值来说，那就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 20); // Java20
		
		// 优先级问题
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 20 + 30); // Java2030
		
		System.out.println(str2 + (20 + 30)); // Java50
	}
}
#$
运算符:
+ 加法
- 减法
* 乘法
/ 除法 (不整除只取商.余数不显示)
% 取模(取相除的余数)
++ 自加
-- 自减


#$

asscll
48 0
65 A
97 a 
unicode万国码
#$
字符(一个,键盘码,单引号)
char str='A';//65
System.out.println(str+0);//65
#$
基本数据类型:
整数型 byte short int(默认) long 

浮点型 float double(双精度默认)
字符型 char
布尔型 boolean
引用数据类型:
字符串
类
数组
接口
Lambda
#$
数组
//创建长度为4的整型数组,默认值为0
int[] a = new int[4];
		a[0] = 5;
		System.out.println(a[0]);
		a[1]=7;
		System.out.println(a[1]);
#$
数组
int[] a = { 4, 8, 2 };
		System.out.println(a[0]);
#$
类和对象
对象是类的实例
public class Main
{
	public static void main(String[] args)
	{
		Rectangle rect = new Rectangle();	
		rect.width = 100;
		System.out.println(rect.width);
		rect.height = 200;
		System.out.println(rect.height);
		
	}
}

class Rectangle
{
	int width;
	int height;
}
#$
类和对象
类作为另一个类的类型
public class Main
{
	public static void main(String[] args)
	{
		Rectangle rect = new Rectangle();
		rect.width = 100;
		System.out.println(rect.width);
		rect.height = 200;
		System.out.println(rect.height);
		
		Rectangle rect2 = new Rectangle();
		rect2.width = 10;
		System.out.println(rect2.width);
		rect2.height = 20;
		System.out.println(rect2.height);
		
		Point p = new Point();
		p.x = 4;
		p.y = 5;
		System.out.println(p.x);
		System.out.println(p.y);
		rect2.position=p;
		System.out.println(rect2.position.x);
		System.out.println(rect2.position.y);
	
		}
}

class Point
{
	int x;
	int y;
}

class Rectangle
{
	int width;
	int height;
	Point position;
}
#$
构造器
public class Main
{
	public static void main(String[] args)
	{
		Rectangle rect = new Rectangle(100,200);
		System.out.println(rect.width);
		System.out.println(rect.height);
	}
}

class Rectangle
{
	int width;
	int height;
	
	// A constructor
	Rectangle(int width,int height)
	{
		this.width = width;
		this.height=height;
		
	}
	
	
}
#$



`;
export {
java,
}
